package com.example.demo.zaqizabatest.函数接口;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;

/**
 * @ClassName Other
 * @Author lys4134
 * @Date 2021/08/13 15:28:46
 * @Description Other
 * @Version 1.0
 **/
public class Other {
    /**
     * Consumer<T>	表示接受一个参数，但不返回任何结果的操作
     * DoubleBinaryOperator	表示接受两个double类型的参数，并返回double类型结果的操作
     * DoubleConsumer	表示接受一个double类型的参数，但不返回任何结果的操作
     * DoubleFunction<R>	表示接受一个double类型的参数，且返回一个R类型的结果的操作
     * DoublePredicate	表示一个接受两个double类型的参数，且返回一个布尔类型的结果的操作
     * DoubleSupplier	表示一个不接受任何参数，但返回布尔类型的结果的操作
     * DoubleToIntFunction	表示接受两个double类型的参数，但返回一个int类型的结果的操作
     * DoubleToLongFunction	表示接受两个double类型的参数，但返回一个long类型的结果的操作
     * DoubleUnaryOperator	表示接受一个double类型的参数，且返回一个double类型的结果的操作
     * Function<T,R>	表示一个接受T类型的参数，且返回一个R类型结果的函数
     * IntBinaryOperator	表示一个接受两个int类型的参数，且返回一个int类型的结果的操作
     * IntConsumer	表示接受一个int类型的参数，但不返回任何结果的操作
     * IntFunction<R>	表示接受一个int类型的参数，但返回一个R类型的结果的操作
     * IntPredicate	表示接受一个int类型的参数，但返回布尔类型的结果的操作
     * IntSupplier	表示不接受任何参数，但返回一个int类型的结果的操作
     * IntToDoubleFunction	表示接受一个int类型的参数，但返回一个double类型的结果的操作
     * IntToLongFunction	表示接受一个int类型的参数，但返回一个long类型的结果的操作
     * IntUnaryOperator	表示接受一个int类型的参数，且返回一个int类型的结果的操作
     * LongBinaryOperator	表示接受两个long类型的参数，且返回一个long类型的结果的操作
     * LongConsumer	表示不接受任何参数，但返回一个long类型的结果的操作
     * LongFunction<R>	表示接受一个loing类型的参数，但返回一个R类型的结果的操作
     * LongPredicate	表示接受一个long类型的参数，但返回布尔类型的结果的操作
     * LongSupplier	表示不接受任何参数，但返回一个long类型的结果的操作
     * LongToDoubleFunction	表示接受一个long类型的参数，但返回一个double类型的结果的函数
     * LongToIntFunction	表示接受一个long类型的参数，但返回int类型的结果的函数
     * LongUnaryOperator	表示接受一个long类型的参数，并返回一个long类型的结果的操作
     * ObjDoubleConsumer<T>	表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作
     * ObjIntConsumer<T>	表示接受两个参数，一个为T类型的对象，另一个int类型，但不返回任何结果的操作
     * ObjLongConsumer<T>	表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作
     * Predicate<T>	表示接受一个指定类型T的参数，但返回布尔类型的结果的操作
     * Supplier<T>	表示不接受任何参数，但返回一个T类型的结果的操作
     * ToDoubleBiFunction<T,U>	表示接受两个不同类型的参数，但返回一个double类型的结果的操作
     * ToDoubleFunction<T>	表示一个接受指定类型T的参数，并返回一个double类型的结果的操作
     * ToIntBiFunction<T,U>	表示接受两个不同类型的参数，但返回一个int类型的结果的操作
     * ToIntFunction<T>	表示一个接受指定类型T的参数，并返回一个int类型的结果的操作
     * ToLongBiFunction<T,U>	表示接受两个不同类型的参数，但返回一个long类型的结果的操作
     * ToLongFunction<T>	表示一个接受指定类型的参数，并返回一个long类型的结果的操作
     * UnaryOperator<T>	表示接受一个参数，并返回一个与参数类型相同的结果的操作
     */
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {


        Class c = Class.forName("com.example.demo.zaqizabatest.函数接口.BiFunctionTest");
        BiFunctionTest biFunctionTest = (BiFunctionTest) c.newInstance();
        Method eval = c.getMethod("eval", String.class, String.class, BiFunction.class);
        Object invoke = eval.invoke(biFunctionTest, "a", "b", new BiFunction<String, String, Map<String, String>>() {
            @Override
            public Map<String, String> apply(String a, String b) {
                Map<String, String> map = new HashMap<>();
                map.put(a, b);
                return map;
            }
        });




        /*String ss = "DoubleBinaryOperator\t表示接受两个double类型的参数，并返回double类型结果的操作\n" +
                "DoubleConsumer\t表示接受一个double类型的参数，但不返回任何结果的操作\n" +
                "DoubleFunction<R>\t表示接受一个double类型的参数，且返回一个R类型的结果的操作\n" +
                "DoublePredicate\t表示一个接受两个double类型的参数，且返回一个布尔类型的结果的操作\n" +
                "DoubleSupplier\t表示一个不接受任何参数，但返回布尔类型的结果的操作\n" +
                "DoubleToIntFunction\t表示接受两个double类型的参数，但返回一个int类型的结果的操作\n" +
                "DoubleToLongFunction\t表示接受两个double类型的参数，但返回一个long类型的结果的操作\n" +
                "DoubleUnaryOperator\t表示接受一个double类型的参数，且返回一个double类型的结果的操作\n" +
                "Function<T,R>\t表示一个接受T类型的参数，且返回一个R类型结果的函数\n" +
                "IntBinaryOperator\t表示一个接受两个int类型的参数，且返回一个int类型的结果的操作\n" +
                "IntConsumer\t表示接受一个int类型的参数，但不返回任何结果的操作\n" +
                "IntFunction<R>\t表示接受一个int类型的参数，但返回一个R类型的结果的操作\n" +
                "IntPredicate\t表示接受一个int类型的参数，但返回布尔类型的结果的操作\n" +
                "IntSupplier\t表示不接受任何参数，但返回一个int类型的结果的操作\n" +
                "IntToDoubleFunction\t表示接受一个int类型的参数，但返回一个double类型的结果的操作\n" +
                "IntToLongFunction\t表示接受一个int类型的参数，但返回一个long类型的结果的操作\n" +
                "IntUnaryOperator\t表示接受一个int类型的参数，且返回一个int类型的结果的操作\n" +
                "LongBinaryOperator\t表示接受两个long类型的参数，且返回一个long类型的结果的操作\n" +
                "LongConsumer\t表示不接受任何参数，但返回一个long类型的结果的操作\n" +
                "LongFunction<R>\t表示接受一个loing类型的参数，但返回一个R类型的结果的操作\n" +
                "LongPredicate\t表示接受一个long类型的参数，但返回布尔类型的结果的操作\n" +
                "LongSupplier\t表示不接受任何参数，但返回一个long类型的结果的操作\n" +
                "LongToDoubleFunction\t表示接受一个long类型的参数，但返回一个double类型的结果的函数\n" +
                "LongToIntFunction\t表示接受一个long类型的参数，但返回int类型的结果的函数\n" +
                "LongUnaryOperator\t表示接受一个long类型的参数，并返回一个long类型的结果的操作\n" +
                "ObjDoubleConsumer<T>\t表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作\n" +
                "ObjIntConsumer<T>\t表示接受两个参数，一个为T类型的对象，另一个int类型，但不返回任何结果的操作\n" +
                "ObjLongConsumer<T>\t表示接受两个参数，一个为T类型的对象，另一个double类型，但不返回任何结果的操作\n" +
                "Predicate<T>\t表示接受一个指定类型T的参数，但返回布尔类型的结果的操作\n" +
                "Supplier<T>\t表示不接受任何参数，但返回一个T类型的结果的操作\n" +
                "ToDoubleBiFunction<T,U>\t表示接受两个不同类型的参数，但返回一个double类型的结果的操作\n" +
                "ToDoubleFunction<T>\t表示一个接受指定类型T的参数，并返回一个double类型的结果的操作\n" +
                "ToIntBiFunction<T,U>\t表示接受两个不同类型的参数，但返回一个int类型的结果的操作\n" +
                "ToIntFunction<T>\t表示一个接受指定类型T的参数，并返回一个int类型的结果的操作\n" +
                "ToLongBiFunction<T,U>\t表示接受两个不同类型的参数，但返回一个long类型的结果的操作\n" +
                "ToLongFunction<T>\t表示一个接受指定类型的参数，并返回一个long类型的结果的操作\n" +
                "UnaryOperator<T>\t表示接受一个参数，并返回一个与参数类型相同的结果的操作";
        String[] sss = ss.split("\n");
        for (String s : sss){
            String[] strings = s.split("\t");
            System.out.println(strings[0] + "(\"" + strings[0] + "\", \"" + strings[0] + "\", \"" + strings[1] + "\"),");
        }*/
    }

}
